﻿using System;
using System.Collections.Generic;
using System.Net;
using System.Security.Cryptography.X509Certificates;
using System.Xml;
using System.Xml.Linq;

using Microsoft.WindowsAzure.ServiceManagementClient;
using Microsoft.WindowsAzure.ServiceManagementClient.Protocol;

namespace Test.AzureSDKPlayground
{
    class Program
    {
        // Set these constants with your values to run the sample.
        private static string Version = "2011-10-01";
        //private static string Thumbprint = "‎546C09D52FCEB82FC2343C08B73D78679A3B0DDA";
        private static string SubscriptionId = "f5ab3daa-913e-4088-a33a-69ecd9d567ca";

        static void Main(string[] args)
        {
            CloudManagmentAccount account = new CloudManagmentAccount();

            account.ApiCertificate = GetStoreCertificate("546C09D52FCEB82FC2343C08B73D78679A3B0DDA");
            account.SubscriptionId = SubscriptionId;

            CloudManagmentClient client = new CloudManagmentClient(account);

            foreach (CloudHostedService service in client.ListHostedSerivces())
            {
                Console.WriteLine(service.Name);

                
            }

            

                /*
            try
            {
                // Obtain the certificate with the specified thumbprint
                X509Certificate2 certificate = GetStoreCertificate("546C09D52FCEB82FC2343C08B73D78679A3B0DDA");
                ListHostedServicesExample(SubscriptionId, certificate, Version);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Exception caught in Main:");
                Console.WriteLine(ex.Message);
            }
                */
            Console.Write("Press any key to continue:");
            Console.ReadKey();
        }

        public static void ListHostedServicesExample(
            string subscriptionId,
            X509Certificate2 certificate,
            string version)
        {
            string uriFormat = "https://management.core.windows.net/{0}/" +
                "services/hostedservices";
            Uri uri = new Uri(String.Format(uriFormat, subscriptionId));

            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(uri);
            request.Method = "GET";
            request.Headers.Add("x-ms-version", version);
            request.ClientCertificates.Add(certificate);
            request.ContentType = "application/xml";

            XDocument responseBody = null;
            HttpStatusCode statusCode;
            HttpWebResponse response;
            try
            {
                response = (HttpWebResponse)request.GetResponse();
            }
            catch (WebException ex)
            {
                // GetResponse throws a WebException for 400 and 500 status codes
                response = (HttpWebResponse)ex.Response;
            }
            statusCode = response.StatusCode;
            if (response.ContentLength > 0)
            {
                using (XmlReader reader = XmlReader.Create(response.GetResponseStream()))
                {
                    responseBody = XDocument.Load(reader);
                }
            }
            response.Close();
            if (statusCode.Equals(HttpStatusCode.OK))
            {
                XNamespace wa = "http://schemas.microsoft.com/windowsazure";
                XElement hostedServices = responseBody.Element(wa + "HostedServices");
                Console.WriteLine(
                    "Hosted Services for Subscription ID {0}:{1}{2}",
                    subscriptionId,
                    Environment.NewLine,
                    hostedServices.ToString(SaveOptions.OmitDuplicateNamespaces));
            }
            else
            {
                Console.WriteLine("Call to List Hosted Services returned an error:");
                Console.WriteLine("Status Code: {0} ({1}):{2}{3}",
                    (int)statusCode, statusCode, Environment.NewLine,
                    responseBody.ToString(SaveOptions.OmitDuplicateNamespaces));
            }
            return;
        }

        /// <summary>
        /// Gets the certificate matching the thumbprint from the local store.
        /// Throws an ArgumentException if a matching certificate is not found.
        /// </summary>
        /// <param name="thumbprint">The thumbprint of the certificate to find.</param>
        /// <returns>The certificate with the specified thumbprint.</returns>
        private static X509Certificate2 GetStoreCertificate(string thumbprint)
        {
            List<StoreLocation> locations = new List<StoreLocation> 
            { 
                StoreLocation.CurrentUser, 
                StoreLocation.LocalMachine 
            };

            foreach (var location in locations)
            {
                X509Store store = new X509Store("My", location);
                try
                {
                    store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
                    X509Certificate2Collection certificates = store.Certificates.Find(
                        X509FindType.FindByThumbprint, thumbprint, false);
                    if (certificates.Count == 1)
                    {
                        return certificates[0];
                    }
                }
                finally
                {
                    store.Close();
                }
            }

            throw new ArgumentException(string.Format(
                "A Certificate with Thumbprint '{0}' could not be located.",
                thumbprint));
        }
    }
}
